#!/usr/bin/env python3
"""
GUI管理模块 - 提供TKinter窗口和系统托盘图标功能
"""

import os
import sys
import threading
import webbrowser
import tkinter as tk
from tkinter import ttk, messagebox
from PIL import Image, ImageTk
import pystray
from flask import Flask
from win32trace import blockingread


class GUIManager:
    """GUI管理器，提供TKinter窗口和系统托盘功能"""

    def __init__(self, flask_app: Flask = None):
        self.flask_app = flask_app
        self.tk_root = None
        self.tray_icon = None
        self.is_running = False
        self.status_var = None
        self.url_var = None

    def create_tk_window(self):
        """创建TKinter主窗口"""
        self.tk_root = tk.Tk()
        self.tk_root.title("项目管理系统 - 控制面板")
        self.tk_root.geometry("350x350")
        self.tk_root.resizable(False, False)

        # 设置图标（如果有）
        try:
            icon_path = os.path.join('static', 'favicon.ico')
            if os.path.exists(icon_path):
                self.tk_root.iconbitmap(icon_path)
        except:
            pass

        # 创建界面
        self._create_ui()

        # 窗口关闭事件
        self.tk_root.protocol("WM_DELETE_WINDOW", self.minimize_to_tray)

        return self.tk_root

    def _create_ui(self):
        """创建UI界面"""
        # 配置样式
        style = ttk.Style()

        # 尝试使用现代主题
        available_themes = style.theme_names()
        modern_themes = ['vista', 'xpnative', 'winnative', 'clam']
        selected_theme = 'clam'
        for theme in modern_themes:
            if theme in available_themes:
                selected_theme = theme
                break
        style.theme_use(selected_theme)

        # 核心配色方案（蓝紫主调+中性灰）
        self.colors = {
            "primary": "#3498db",  # 主操作色（打开管理界面）
            "secondary": "#e2e8f0",  # 次要按钮/边框
            "success": "#27ae60",  # 成功状态
            "text-primary": "#2d3748",  # 主文字
            "text-secondary": "#4a5568",  # 次文字
            "bg": "#f0f2f5",  # 窗口背景
            "card-bg": "#ffffff"  # 卡片背景
        }

        # 基础样式配置
        style.configure("TFrame", background=self.colors["bg"])
        style.configure("TLabel", background=self.colors["card-bg"], font=('Segoe UI', 9))
        style.configure("TLabelframe", background=self.colors["card-bg"], relief="groove", borderwidth=1)
        style.configure("TLabelframe.Label", font=('Segoe UI', 10, 'bold'), foreground=self.colors["text-primary"])

        # 标题样式（主标题+副标题）
        style.configure('Title.TLabel',
                        font=('Segoe UI', 22, 'bold'),
                        foreground='#211110',
                        background='#ffffff')

        style.configure('Card.TLabelframe',
                        relief='solid',
                        borderwidth=1,
                        background='#ffffff')

        style.configure('Card.TLabelframe.Label',
                        font=('Segoe UI', 10, 'bold'),
                        foreground='#34195e',
                        background='#ffffff')

        # 卡片按钮样式（主要操作）
        style.configure('Accent.TButton',
                        font=('Segoe UI', 9, 'bold'),
                        foreground='white',
                        focuscolor='none',
                        background='#ffffff'
                        )
        # 次要按钮样式（最小化/退出）
        style.map('Accent.TButton',
                  background=[('active', '#2980b9')])

        # 状态标签样式
        style.configure('Success.TLabel',
                        foreground='#000000',
                        background='#ffffff')

        style.configure('Info.TLabel',
                        foreground='#000000',
                        background='#ffffff')

        # 主框架 - 使用卡片式设计
        main_frame = ttk.Frame(self.tk_root, padding="25", style='Card.TLabelframe')
        main_frame.grid(row=0, column=0, sticky=(tk.W, tk.E, tk.N, tk.S), padx=20, pady=20)

        # 设置窗口背景色
        self.tk_root.configure(background='#ecf0f1')

        # 标题 - 使用更现代的字体和颜色
        title_label = ttk.Label(main_frame,
                                text="项目管理系统",
                                style='Title.TLabel')
        title_label.grid(row=0, column=0, columnspan=2, pady=(0, 25))

        # 状态信息 - 卡片式设计
        status_frame = ttk.LabelFrame(main_frame,
                                      text="📊 系统状态",
                                      padding="15",
                                      style='Card.TLabelframe')
        status_frame.grid(row=1, column=0, columnspan=2, sticky=(tk.W, tk.E), pady=(0, 15))

        # 状态标签网格布局
        status_frame.columnconfigure(1, weight=1)

        # 运行状态
        ttk.Label(status_frame,
                  text="运行状态:",
                  font=('Segoe UI', 9, 'bold')).grid(row=0, column=0, sticky=tk.W, pady=5)
        self.status_var = tk.StringVar(value="运行中")
        status_label = ttk.Label(status_frame,
                                 textvariable=self.status_var,
                                 style='Success.TLabel')
        status_label.grid(row=0, column=1, sticky=tk.W, pady=5)

        # 服务地址
        ttk.Label(status_frame,
                  text="服务地址:",
                  font=('Segoe UI', 9, 'bold')).grid(row=1, column=0, sticky=tk.W, pady=5)
        host = self.flask_app.config.get('HOST', '127.0.0.1')
        port = self.flask_app.config.get('PORT', 5001)
        self.url_var = tk.StringVar(value=f"http://{host}:{port}")
        url_label = ttk.Label(status_frame,
                              textvariable=self.url_var,
                              style='Info.TLabel')
        url_label.grid(row=1, column=1, sticky=tk.W, pady=5)

        # 添加复制链接功能
        def copy_url():
            self.tk_root.clipboard_clear()
            self.tk_root.clipboard_append(self.url_var.get())
            # 临时显示复制成功提示
            original_text = url_label.cget('text')
            url_label.configure(style='Success.TLabel', text="✓ 已复制到剪贴板")
            self.tk_root.after(2000, lambda: url_label.configure(
                style='Info.TLabel',
                textvariable=self.url_var
            ))

        copy_btn = ttk.Button(status_frame,
                              text="📋",
                              width=3,
                              command=copy_url)
        copy_btn.grid(row=1, column=2, padx=(10, 0))

        # 控制按钮 - 使用强调色
        button_frame = ttk.Frame(main_frame)
        button_frame.grid(row=2, column=0, columnspan=2, pady=25)

        # 主要操作按钮
        open_btn = ttk.Button(button_frame,
                              text="🌐 打开管理界面",
                              command=self.open_web_interface,
                              style='Accent.TButton')
        open_btn.pack(side=tk.LEFT, padx=8)

        minimize_btn = ttk.Button(button_frame,
                                  text="📌 最小化到托盘",
                                  command=self.minimize_to_tray)
        minimize_btn.pack(side=tk.LEFT, padx=8)

        quit_btn = ttk.Button(button_frame,
                              text="❌ 退出应用程序",
                              command=self.quit_application)
        quit_btn.pack(side=tk.LEFT, padx=8)

        # 关于信息 - 更简洁的设计
        about_frame = ttk.LabelFrame(main_frame,
                                     text="ℹ️ 关于",
                                     padding="15",
                                     style='Card.TLabelframe')
        about_frame.grid(row=3, column=0, columnspan=2, sticky=(tk.W, tk.E))

        about_text = """项目管理系统 v1.0

    基于 Flask + Tkinter 开发
    提供完整的项目管理功能
    支持后台服务和系统托盘"""

        about_label = ttk.Label(about_frame,
                                text=about_text,
                                justify=tk.LEFT,
                                font=('Segoe UI', 9),
                                background='#ffffff')
        about_label.pack()

        # 底部版权信息
        copyright_label = ttk.Label(main_frame,
                                    text="© 2024 项目管理系统 - All rights reserved",
                                    font=('Segoe UI', 8),
                                    foreground='#018100',
                                    background='#ffffff')
        copyright_label.grid(row=4, column=0, columnspan=2, pady=(20, 0))

        # 配置网格权重
        self.tk_root.columnconfigure(0, weight=1)
        self.tk_root.rowconfigure(0, weight=1)
        main_frame.columnconfigure(1, weight=1)

        # 设置窗口最小尺寸
        self.tk_root.minsize(450, 500)

        # 居中窗口
        self._center_window()

    def _center_window(self):
        """居中显示窗口"""
        self.tk_root.update_idletasks()
        width = self.tk_root.winfo_width()
        height = self.tk_root.winfo_height()
        x = (self.tk_root.winfo_screenwidth() // 2) - (width // 2)
        y = (self.tk_root.winfo_screenheight() // 2) - (height // 2)
        self.tk_root.geometry('{}x{}+{}+{}'.format(width, height, x, y))

    def open_web_interface(self):
        """打开Web管理界面"""
        try:
            webbrowser.open(self.url_var.get())
        except Exception as e:
            messagebox.showerror("错误", f"无法打开浏览器: {e}")

    def minimize_to_tray(self):
        """最小化到系统托盘"""
        if self.tk_root:
            self.tk_root.withdraw()
        self.create_system_tray()

    def restore_from_tray(self):
        """从系统托盘恢复窗口"""
        if self.tray_icon:
            self.tray_icon.stop()
        if self.tk_root:
            self.tk_root.deiconify()

    def create_system_tray(self):
        """创建系统托盘图标"""

        def create_image():
            # 创建美观的托盘图标
            import logging
            logging.getLogger('PIL').setLevel(logging.WARNING)  # 减少Pillow的调试输出

            from PIL import Image, ImageDraw, ImageFont, ImageFilter
            try:
                # 创建图像
                size = (64, 64)
                image = Image.new('RGBA', size, (0, 0, 0, 0))
                draw = ImageDraw.Draw(image)

                # 创建渐变背景 - 蓝色渐变
                for i in range(size[0]):
                    # 从深蓝到浅蓝的渐变
                    r = int(30 + i * 1.5)
                    g = int(80 + i * 1.2)
                    b = int(200 - i * 0.8)
                    draw.line([(i, 0), (i, size[1])], fill=(r, g, b, 255))

                # 添加圆形背景
                circle_margin = 4
                circle_radius = size[0] // 2 - circle_margin

                # 绘制阴影效果
                shadow_offset = 2
                draw.ellipse(
                    [
                        circle_margin + shadow_offset,
                        circle_margin + shadow_offset,
                        size[0] - circle_margin + shadow_offset,
                        size[1] - circle_margin + shadow_offset
                    ],
                    fill=(0, 0, 0, 100)
                )

                # 绘制主圆形
                draw.ellipse(
                    [
                        circle_margin,
                        circle_margin,
                        size[0] - circle_margin,
                        size[1] - circle_margin
                    ],
                    fill=(70, 130, 230, 255)
                )

                # 添加高光效果
                highlight_radius = circle_radius - 8
                draw.ellipse(
                    [
                        circle_margin + 8,
                        circle_margin + 8,
                        circle_margin + 8 + highlight_radius,
                        circle_margin + 8 + highlight_radius
                    ],
                    fill=(120, 180, 255, 150)
                )

                # 尝试加载字体
                try:
                    # 尝试使用系统字体
                    font_sizes = [36, 32, 28]  # 尝试不同大小
                    font = None
                    for font_size in font_sizes:
                        try:
                            font = ImageFont.truetype("arial.ttf", font_size)
                            break
                        except:
                            try:
                                font = ImageFont.truetype("arialbd.ttf", font_size)  # 粗体
                                break
                            except:
                                continue

                    if font is None:
                        # 如果找不到字体，使用默认字体
                        font = ImageFont.load_default()
                except:
                    font = ImageFont.load_default()

                # 添加文字
                text = "K"
                # 获取文字尺寸
                bbox = draw.textbbox((0, 0), text, font=font)
                text_width = bbox[2] - bbox[0]
                text_height = bbox[3] - bbox[1]

                # 计算居中位置（稍微偏上一点，视觉上更居中）
                x = (size[0] - text_width) // 2
                y = (size[1] - text_height) // 2 - 2

                # 添加文字阴影
                shadow_color = (0, 0, 0, 150)
                draw.text((x + 1, y + 1), text, fill=shadow_color, font=font)

                # 添加主文字（白色）
                draw.text((x, y), text, fill="white", font=font)

                return image
            except Exception as e:
                print(f"创建托盘图标失败: {e}")
                # 返回一个简单的默认图标
                image = Image.new('RGB', (64, 64), color='gray')
                draw = ImageDraw.Draw(image)
                draw.text((20, 20), "K", fill="white")
                return image

        # 托盘菜单
        menu = pystray.Menu(
            pystray.MenuItem("显示窗口", self.restore_from_tray),
            pystray.MenuItem("打开网址", self.open_web_interface),
            pystray.MenuItem("退出应用", self.quit_application)
        )

        # 创建托盘图标
        self.tray_icon = pystray.Icon(
            "project_management",
            create_image(),
            "项目管理系统",
            menu
        )

        # 在后台线程中运行托盘图标
        def run_tray():
            self.tray_icon.run()

        tray_thread = threading.Thread(target=run_tray, daemon=True)
        tray_thread.start()

    def quit_application(self):
        """退出应用程序"""
        if messagebox.askyesno("确认退出", "确定要退出项目管理系统吗？"):
            # 停止托盘图标
            if self.tray_icon:
                self.tray_icon.stop()

            # 停止Flask应用
            if self.flask_app and hasattr(self.flask_app, 'shutdown'):
                self.flask_app.shutdown()

            # 关闭TKinter窗口
            if self.tk_root:
                self.tk_root.quit()
                self.tk_root.destroy()

            # 退出程序
            os._exit(0)

    def start_gui(self):
        """启动GUI界面"""
        if not self.tk_root:
            self.create_tk_window()

        self.is_running = True
        self.tk_root.mainloop()

    def update_status(self, status: str, url: str = None):
        """更新状态信息"""
        if self.status_var:
            self.status_var.set(status)
        if url and self.url_var:
            self.url_var.set(url)

    def update_from_flask_config(self, flask_app: Flask):
        """从Flask配置更新GUI状态"""
        if flask_app and self.url_var:
            # 优先从环境变量读取（确保获取的是.env中的最新值）
            host = os.environ.get('FLASK_HOST', flask_app.config.get('FLASK_HOST', '127.0.0.1'))
            port = os.environ.get('FLASK_PORT', flask_app.config.get('FLASK_PORT', '5001'))
            # 将0.0.0.0转换为127.0.0.1显示
            display_host = '127.0.0.1' if host == '0.0.0.0' else host
            self.url_var.set(f"http://{display_host}:{port}")

def run_with_gui(flask_app: Flask):
    """使用GUI运行Flask应用"""
    # 确保环境变量已加载（从 .env 文件）
    try:
        from inc.config import load_configuration
        load_configuration()
        print("✅ GUI模式：环境变量配置已加载")
    except Exception as e:
        print(f"⚠️ GUI模式：环境变量加载失败: {e}")

    # 创建GUI管理器
    gui_manager = GUIManager(flask_app)

    # 创建TKinter窗口
    gui_manager.create_tk_window()

    # 从Flask配置更新GUI状态
    gui_manager.update_from_flask_config(flask_app)
    gui_manager.update_status("运行中")

    # 在后台线程中运行Flask应用
    def run_flask():
        try:
            # 从环境变量读取配置（确保使用.env中的值）
            host = os.environ.get('FLASK_HOST', flask_app.config.get('FLASK_HOST', '127.0.0.1'))
            port = int(os.environ.get('FLASK_PORT', flask_app.config.get('FLASK_PORT', 5001)))
            debug = os.environ.get('FLASK_DEBUG', 'false').lower() == 'true'

            flask_app.run(
                host=host,
                port=port,
                debug=debug,
                use_reloader=False
            )
        except Exception as e:
            print(f"Flask应用启动失败: {e}")
            if gui_manager.tk_root:
                messagebox.showerror("错误", f"Flask应用启动失败: {e}")

    flask_thread = threading.Thread(target=run_flask, daemon=True)
    flask_thread.start()

    # 启动GUI
    gui_manager.start_gui()
    print("✅ GUI模式：应用已退出")
    sys.exit(0)